In [1]:
import swat
conn = swat.CAS(host, port, username, password)
help ActionThe CAS server has a builtin help system that will tell you about action sets and actions. To get help for all of the loaded action sets and a description of all of the actions in those action sets, you just call the help action with no parameters. In this case, we are storing the output of the action to a variable. That result contains the same information as the printed notes, but the information in encapsulated in DataFrame structures. Unless you are going to use the action set information programmatically, there isn't much reason to have it printed twice.
In [2]:
out = conn.help()
NOTE: Available Action Sets and Actions:
NOTE: accessControl
NOTE: assumeRole - Assumes a role
NOTE: dropRole - Relinquishes a role
NOTE: showRolesIn - Shows the currently active role
NOTE: showRolesAllowed - Shows the roles that a user is a member of
NOTE: isInRole - Shows whether a role is assumed
NOTE: isAuthorized - Shows whether access is authorized
NOTE: isAuthorizedActions - Shows whether access is authorized to actions
NOTE: isAuthorizedTables - Shows whether access is authorized to tables
NOTE: isAuthorizedColumns - Shows whether access is authorized to columns
NOTE: listAllPrincipals - Lists all principals that have explicit access controls
NOTE: whatIsEffective - Lists effective access and explanations (Origins)
NOTE: listAcsData - Lists access controls for caslibs, tables, and columns
NOTE: listAcsActionSet - Lists access controls for an action or action set
NOTE: repAllAcsCaslib - Replaces all access controls for a caslib
NOTE: repAllAcsTable - Replaces all access controls for a table
NOTE: repAllAcsColumn - Replaces all access controls for a column
NOTE: repAllAcsActionSet - Replaces all access controls for an action set
NOTE: repAllAcsAction - Replaces all access controls for an action
NOTE: updSomeAcsCaslib - Adds, deletes, and modifies some access controls for a caslib
NOTE: updSomeAcsTable - Adds, deletes, and modifies some access controls for a table
NOTE: updSomeAcsColumn - Adds, deletes, and modifies some access controls for a column
NOTE: updSomeAcsActionSet - Adds, deletes, and modifies some access controls for an action set
NOTE: updSomeAcsAction - Adds, deletes, and modifies some access controls for an action
NOTE: remAllAcsData - Removes all access controls for a caslib, table, or column
NOTE: remAllAcsActionSet - Removes all access controls for an action set or action
NOTE: operTableMd - Adds, deletes, and modifies table metadata
NOTE: operColumnMd - Adds, deletes, and modifies column metadata
NOTE: operActionSetMd - Adds, deletes, and modifies action set metadata
NOTE: operActionMd - Adds, deletes, and modifies action metadata
NOTE: operAdminMd - Assigns users and groups to roles and modifies administrator metadata
NOTE: listMetadata - Lists the metadata for caslibs, tables, columns, action sets, actions, or administrators
NOTE: persistMetadata - Persists the access control metadata
NOTE: createBackup - Creates a backup if one is not in progress
NOTE: completeBackup - Flags a backup as complete
NOTE: operBWPaths - Configures a blacklist or whitelist of paths
NOTE: deleteBWList - Deletes a blacklist or a whitelist
NOTE: builtins
NOTE: addNode - Adds a machine to the server
NOTE: removeNode - Remove one or more machines from the server
NOTE: help - Shows the parameters for an action or lists all available actions
NOTE: listNodes - Shows the host names used by the server
NOTE: loadActionSet - Loads an action set for use in this session
NOTE: installActionSet - Loads an action set in new sessions automatically
NOTE: log - Shows and modifies logging levels
NOTE: queryActionSet - Shows whether an action set is loaded
NOTE: queryName - Checks whether a name is an action or action set name
NOTE: reflect - Shows detailed parameter information for an action or all actions in an action set
NOTE: serverStatus - Shows the status of the server
NOTE: about - Shows the status of the server
NOTE: shutdown - Shuts down the server
NOTE: getUsers - Shows the users from the authentication provider
NOTE: getGroups - Shows the groups from the authentication provider
NOTE: userInfo - Shows the user information for your connection
NOTE: actionSetInfo - Shows the build information from loaded action sets
NOTE: history - Shows the actions that were run in this session
NOTE: casCommon - Provides parameters that are common to many actions
NOTE: ping - Sends a single request to the server to confirm that the connection is working
NOTE: echo - Prints the supplied parameters to the client log
NOTE: modifyQueue - Modifies the action response queue settings
NOTE: getLicenseInfo - Shows the license information for a SAS product
NOTE: refreshLicense - Refresh SAS license information from a file
NOTE: httpAddress - Shows the HTTP address for the server monitor
NOTE: configuration
NOTE: getServOpt - displays the value of a server option
NOTE: listServOpts - Displays the server options and server values
NOTE: dataPreprocess
NOTE: rustats - Computes robust univariate statistics, centralized moments, quantiles, and frequency distribution statistics
NOTE: impute - Performs data matrix (variable) imputation
NOTE: outlier - Performs outlier detection and treatment
NOTE: binning - Performs unsupervised variable discretization
NOTE: discretize - Performs supervised and unsupervised variable discretization
NOTE: histogram - Generates histogram bins and simple bin-based statistics for numeric variables
NOTE: transform - Performs pipelined variable imputation, outlier detection and treatment, functional transformation, binning, and robust univariate statistics to evaluate the quality of the transformation
NOTE: kde - Computes kernel density estimation
NOTE: dataStep
NOTE: runCode - Runs DATA step code
NOTE: percentile
NOTE: percentile - Calculate quantiles and percentiles
NOTE: boxPlot - Calculate quantiles, high and low whiskers, and outliers
NOTE: assess - Assess and compare models
NOTE: search
NOTE: searchIndex - Searches for a query against an index and retrieves records, documents, and tuples that are relevant to that query
NOTE: searchAggregate - Aggregates certain fields in a table that is usually generated by searchIndex
NOTE: valueCount - value count for multiple fields
NOTE: buildIndex - Creates an empty index using a schema (the first step of Search)
NOTE: getSchema - Gets the schema of an index
NOTE: appendIndex - Loads data to an index after the buildIndex action is performed
NOTE: deleteDocuments - Delete a portion of documents from index
NOTE: session
NOTE: listSessions - Displays a list of the sessions on the server
NOTE: addNodeStatus - Lists details about machines currently being added to the server
NOTE: timeout - Changes the time-out for a session
NOTE: endSession - Ends the current session
NOTE: sessionId - Displays the name and UUID of the current session
NOTE: sessionName - Changes the name of the current session
NOTE: sessionStatus - Displays the status of the current session
NOTE: listresults - Lists the saved results for a session
NOTE: batchresults - Change current action to batch results
NOTE: fetchresult - Fetch the specified saved result for a session
NOTE: flushresult - Flush the saved result for this session
NOTE: setLocale - Changes the locale for the current session
NOTE: metrics - Displays the metrics for each action after it executes
NOTE: sessionProp
NOTE: setSessOpt - Sets a session option
NOTE: getSessOpt - Displays the value of a session option
NOTE: listSessOpts - Displays the session options and session values
NOTE: addFmtLib - Adds a format library
NOTE: listFmtLibs - Lists the format libraries that are associated with the session
NOTE: setFmtSearch - Sets the format libraries to search
NOTE: listFmtSearch - Shows the format library search order
NOTE: dropFmtLib - Drops a format library from global scope for all sessions
NOTE: deleteFormat - Deletes a format from a format library
NOTE: addFormat - Adds a format to a format library
NOTE: listFmtValues - Shows the values for a format
NOTE: saveFmtLib - Saves a format library
NOTE: promoteFmtLib - Promotes a format library to global scope for all sessions
NOTE: listFmtRanges - Displays the range information for a format
NOTE: simple
NOTE: mdSummary - Calculates multidimensional summaries of numeric variables
NOTE: numRows - Shows the number of rows in a Cloud Analytic Services table
NOTE: summary - Generates descriptive statistics of numeric variables such as the sample mean, sample variance, sample size, sum of squares, and so on
NOTE: correlation - Generates a matrix of Pearson product-moment correlation coefficients
NOTE: regression - Performs a linear regression up to 3rd-order polynomials
NOTE: crossTab - Performs one-way or two-way tabulations
NOTE: distinct - Computes the distinct number of values of the variables in the variable list
NOTE: topK - Returns the top-K and bottom-K distinct values of each variable included in the variable list based on a user-specified ranking order
NOTE: groupBy - Builds BY groups in terms of the variable value combinations given the variables in the variable list
NOTE: freq - Generates a frequency distribution for one or more variables
NOTE: paraCoord - Generates a parallel coordinates plot of the variables in the variable list
NOTE: table
NOTE: view - Creates a view from files or tables
NOTE: attribute - Manages extended table attributes
NOTE: upload - Transfers binary data to the server to create objects like tables
NOTE: loadTable - Loads a table from a caslib's data source
NOTE: tableExists - Checks whether a table has been loaded
NOTE: columnInfo - Shows column information
NOTE: fetch - Fetches rows from a table or view
NOTE: save - Saves a table to a caslib's data source
NOTE: addTable - Add a table by sending it from the client to the server
NOTE: tableInfo - Shows information about a table
NOTE: tableDetails - Get detailed information about a table
NOTE: dropTable - Drops a table
NOTE: deleteSource - Delete a table or file from a caslib's data source
NOTE: fileInfo - Lists the files in a caslib's data source
NOTE: promote - Promote a table to global scope
NOTE: addCaslib - Adds a new caslib to enable access to a data source
NOTE: dropCaslib - Drops a caslib
NOTE: caslibInfo - Shows caslib information
NOTE: queryCaslib - Checks whether a caslib exists
NOTE: partition - Partitions a table
NOTE: recordCount - Shows the number of rows in a Cloud Analytic Services table
NOTE: loadDataSource - Loads one or more data source interfaces
NOTE: update - Updates rows in a table
If you only want to see the help for a single action set, you can specify the action set name as a parameter.
In [3]:
out = conn.help(actionset='simple')
NOTE: Information for action set 'simple':
NOTE: simple
NOTE: mdSummary - Calculates multidimensional summaries of numeric variables
NOTE: numRows - Shows the number of rows in a Cloud Analytic Services table
NOTE: summary - Generates descriptive statistics of numeric variables such as the sample mean, sample variance, sample size, sum of squares, and so on
NOTE: correlation - Generates a matrix of Pearson product-moment correlation coefficients
NOTE: regression - Performs a linear regression up to 3rd-order polynomials
NOTE: crossTab - Performs one-way or two-way tabulations
NOTE: distinct - Computes the distinct number of values of the variables in the variable list
NOTE: topK - Returns the top-K and bottom-K distinct values of each variable included in the variable list based on a user-specified ranking order
NOTE: groupBy - Builds BY groups in terms of the variable value combinations given the variables in the variable list
NOTE: freq - Generates a frequency distribution for one or more variables
NOTE: paraCoord - Generates a parallel coordinates plot of the variables in the variable list
You can also specify a single action as a parameter. Calling the help action this way will also print descriptions of all of the action parameters.
In [4]:
out = conn.help(action='summary')
NOTE: Information for action 'simple.summary':
NOTE: The following parameters are accepted. Default values are shown.
NOTE: list table={
NOTE: specifies the table name, caslib, and other common parameters.
NOTE: string name=NULL (required),
NOTE: specifies the name of the table to use.
NOTE: string caslib=NULL,
NOTE: specifies the caslib containing the table that you want to use with the action. By default, the active caslib is used. Specify a value only if you need to access a table from a different caslib.
NOTE: string where=NULL,
NOTE: specifies an expression for subsetting the input data.
NOTE: array of groupBy={
NOTE: specifies the names of the variables to use for grouping results.
NOTE: string name=NULL (required),
NOTE: specifies the name for the variable.
NOTE: string label=NULL,
NOTE: specifies the descriptive label for the variable.
NOTE: int32 formattedLength=0,
NOTE: specifies the format field length plus the format precision length.
NOTE: string format=NULL,
NOTE: specifies the format to apply to the variable.
NOTE: int32 nfl=0,
NOTE: specifies the format field length.
NOTE: int32 nfd=0
NOTE: specifies the format precision length.
NOTE: },
NOTE: specifies the names of the variables to use for grouping results.
NOTE: array of orderBy={
NOTE: specifies the variables to use for ordering observations within partitions. This parameter applies to partitioned tables or it can be combined with groupBy variables when groupByMode is set to REDISTRIBUTE.
NOTE: string name=NULL (required),
NOTE: specifies the name for the variable.
NOTE: string label=NULL,
NOTE: specifies the descriptive label for the variable.
NOTE: int32 formattedLength=0,
NOTE: specifies the format field length plus the format precision length.
NOTE: string format=NULL,
NOTE: specifies the format to apply to the variable.
NOTE: int32 nfl=0,
NOTE: specifies the format field length.
NOTE: int32 nfd=0
NOTE: specifies the format precision length.
NOTE: },
NOTE: specifies the variables to use for ordering observations within partitions. This parameter applies to partitioned tables or it can be combined with groupBy variables when groupByMode is set to REDISTRIBUTE.
NOTE: array of computedVars={
NOTE: specifies the names of the computed variables to create. Specify an expression for each variable in the computedVarsProgram parameter.
NOTE: string name=NULL (required),
NOTE: specifies the name for the variable.
NOTE: string label=NULL,
NOTE: specifies the descriptive label for the variable.
NOTE: int32 formattedLength=0,
NOTE: specifies the format field length plus the format precision length.
NOTE: string format=NULL,
NOTE: specifies the format to apply to the variable.
NOTE: int32 nfl=0,
NOTE: specifies the format field length.
NOTE: int32 nfd=0
NOTE: specifies the format precision length.
NOTE: } (alias: compVars),
NOTE: specifies the names of the computed variables to create. Specify an expression for each variable in the computedVarsProgram parameter.
NOTE: string computedVarsProgram=NULL (alias: compPgm),
NOTE: specifies an expression for each computed variable that you include in the computedVars parameter.
NOTE: enum groupByMode='NOSORT' ('NOSORT', 'REDISTRIBUTE'),
NOTE: specifies how the server creates groups.
NOTE: boolean computedOnDemand=false (alias: compOnDemand),
NOTE: when set to True, the computed variables are created when the table is loaded instead of when the action begins.
NOTE: boolean singlePass=false,
NOTE: when set to True, the data does not create a transient table in the server. Setting this parameter to True can be efficient, but the data might not have stable ordering upon repeated runs.
NOTE: alternative list importOptions={
NOTE: specifies the settings for reading a table from a data source.
NOTE: list : {
NOTE: enum : 'auto' ('auto') (alias: ft)
NOTE: specifies the file type based on the filename suffix. Default values for the parameters related to the file type are used.
NOTE: },
NOTE: list : {
NOTE: enum : 'hdat' ('hdat') (required),
NOTE: specifies to import a SASHDAT table.
NOTE: alternative list : {
NOTE: specifies a password for encrypting or decrypting stored data.
NOTE: string : NULL,
NOTE: blob
NOTE: }
NOTE: specifies a password for encrypting or decrypting stored data.
NOTE: },
NOTE: list : {
NOTE: enum : 'csv' ('csv', 'delimited') (required),
NOTE: specifies to import a delimited file.
NOTE: int64 : 20 (value >= 1),
NOTE: specifies the number of rows to scan in order to determine data types for variables. Specify 0 to scan all rows.
NOTE: string : ',',
NOTE: specifies the character to use as the field delimiter.
NOTE: array of : {
NOTE: specifies the names, types, formats, and other metadata for variables.
NOTE: string : NULL,
NOTE: specifies the name for the variable.
NOTE: string : NULL,
NOTE: specifies the descriptive label for the variable.
NOTE: int32 : 8 (value >= 1),
NOTE: specifies the unformatted length of the variable. This parameter applies to fixed-length character variables (type="CHAR") only.
NOTE: enum : 'double' ('binary', 'char', 'date', 'datetime', 'decquad', 'decsext', 'double', 'int32', 'int64', 'time', 'varbinary', 'varchar'),
NOTE: specifies the data type for the variable.
NOTE: int32 : 0,
NOTE: specifies the format field length plus the format precision length.
NOTE: string : NULL,
NOTE: specifies the format to apply to the variable.
NOTE: int32 : 0,
NOTE: specifies the format field length.
NOTE: int32 : 0
NOTE: specifies the format precision length.
NOTE: },
NOTE: specifies the names, types, formats, and other metadata for variables.
NOTE: boolean : true,
NOTE: when set to True, the values in the first line of the file are used as variable names.
NOTE: boolean : true,
NOTE: when set to True, variable-length strings are used for character variables.
NOTE: int32 : 0 (value >= 0),
NOTE: specifies the number of threads to use on each machine in the server. By default, the server uses one thread for each CPU that is licensed to use SAS software.
NOTE: boolean : false,
NOTE: removes leading and trailing blanks from character variables.
NOTE: string : 'utf-8',
NOTE: specifies the text encoding of the file.
NOTE: string : NULL,
NOTE: specifies the locale for interpreting data in the file
NOTE: boolean : true
NOTE: specifies that truncation of character data that is too long for a given field is allowed.
NOTE: },
NOTE: list : {
NOTE: enum : 'excel' ('excel') (required),
NOTE: imports a Microsoft Excel workbook.
NOTE: string : NULL,
NOTE: specifies the name of the worksheet to import.
NOTE: string : NULL,
NOTE: specifies a subset of the cells to import. For example, the range B2..E8 is the range address for a rectangular block of 12 cells, where the top left cell is B2 and the bottom right cell is E8.
NOTE: boolean : true
NOTE: when set to True, the values in the first line of the file are used as variable names.
NOTE: },
NOTE: list : {
NOTE: enum : 'jmp' ('jmp') (required)
NOTE: imports a JMP file.
NOTE: },
NOTE: list : {
NOTE: enum : 'spss' ('spss') (required)
NOTE: imports an SPSS file.
NOTE: },
NOTE: list : {
NOTE: enum : 'dta' ('dta') (required)
NOTE: imports a STATA file.
NOTE: },
NOTE: list : {
NOTE: enum : 'esp' ('esp') (required),
NOTE: imports a window from SAS Event Stream Processing.
NOTE: boolean : false,
NOTE: when set to True, the table is created with character and float data types only. When set to False, the table uses the same data types that are used in the ESP event.
NOTE: int32 : 5
NOTE: specifies the number of seconds to receive data from SAS Event Stream Processing before declaring an end of file on the stream. The data is read until an end of file is found, and then the action stops running.
NOTE: },
NOTE: list : {
NOTE: enum : 'lasr' ('lasr') (required),
NOTE: imports a table from SAS LASR Analytic Server.
NOTE: string list : {
NOTE: specifies the variables to use in the action.
NOTE: },
NOTE: specifies the variables to use in the action.
NOTE: string : NULL,
NOTE: specifies an expression for subsetting the input data.
NOTE: array of : {
NOTE: specifies the names of the computed variables to create. Specify an expression for each variable in the computedVarsProgram parameter.
NOTE: string : NULL (required),
NOTE: specifies the name for the variable.
NOTE: string : NULL,
NOTE: specifies the descriptive label for the variable.
NOTE: int32 : 0,
NOTE: specifies the format field length plus the format precision length.
NOTE: string : NULL,
NOTE: specifies the format to apply to the variable.
NOTE: int32 : 0,
NOTE: specifies the format field length.
NOTE: int32 : 0
NOTE: specifies the format precision length.
NOTE: },
NOTE: specifies the names of the computed variables to create. Specify an expression for each variable in the computedVarsProgram parameter.
NOTE: string : NULL,
NOTE: specifies an expression for each computed variable that you include in the computedVars parameter.
NOTE: boolean : false,
NOTE: when set to True, variable-length strings are used for character variables.
NOTE: int32 : 0 (value >= 0),
NOTE: specifies the number of threads to use on each machine in the server. By default, the server uses one thread for each CPU that is licensed to use SAS software.
NOTE: enum : 'Fallback' ('Fallback', 'Force', 'None'),
NOTE: specifies how the table is transferred from SAS LASR Analytic Server to SAS Cloud Analytic Services.
NOTE: boolean : false
NOTE: when set to True, the rows are inserted into the new table in the same order as they are received from the SAS LASR Analytic Server. Creating the table is less efficient when this parameter is used.
NOTE: },
NOTE: list : {
NOTE: enum : 'basesas' ('basesas') (required),
NOTE: specifies the settings for importing a SAS data set.
NOTE: alternative list : {
NOTE: specifies a password for encrypting or decrypting stored data.
NOTE: string : NULL,
NOTE: blob
NOTE: },
NOTE: specifies a password for encrypting or decrypting stored data.
NOTE: string : NULL,
NOTE: specifies the password for a password-protected data set. Use this parameter if the data set is password-protected or uses SAS proprietary encryption.
NOTE: string : NULL,
NOTE: specifies the Read password for the SAS data set.
NOTE: enum : 'AUTO' ('AUTO', 'SERIAL', 'PARALLEL') (alias: dtm),
NOTE: specifies how data is transferred between the data source and SAS Cloud Analytic Services.
NOTE: double : 1 (1 <= value <= 5)
NOTE: specifies a multiplier value to expand fixed-width character variables that might require transcoding. The lengths are increased to avoid character data truncation. The lengths are increased by multiplying the length by the specified value.
NOTE: },
NOTE: list : {
NOTE: enum : 'mva' ('mva') (required)
NOTE: imports a table from a Base SAS session.
NOTE: },
NOTE: list : {
NOTE: enum : 'xls' ('xls') (required),
NOTE: imports a Microsoft Excel workbook with an XLS file extension.
NOTE: string : NULL,
NOTE: specifies the name of the worksheet to import.
NOTE: string : NULL,
NOTE: specifies a subset of the cells to import. For example, the range B2..E8 is the range address for a rectangular block of 12 cells, where the top left cell is B2 and the bottom right cell is E8.
NOTE: boolean : true
NOTE: when set to True, the values in the first line of the file are used as variable names.
NOTE: },
NOTE: list : {
NOTE: enum : 'fmt' ('fmt') (required),
NOTE: imports SAS formats from a file.
NOTE: string : NULL
NOTE: specifies a file system path and filename. The file must be a SAS item store that includes the formats to import.
NOTE: }
NOTE: } (alias: import),
NOTE: specifies the settings for reading a table from a data source.
NOTE: boolean onDemand=true,
NOTE: when set to True, table access is less aggressive with virtual memory use.
NOTE: array of vars={
NOTE: specifies the variables to use in the action.
NOTE: string name=NULL (required),
NOTE: specifies the name for the variable.
NOTE: string label=NULL,
NOTE: specifies the descriptive label for the variable.
NOTE: int32 formattedLength=0,
NOTE: specifies the format field length plus the format precision length.
NOTE: string format=NULL,
NOTE: specifies the format to apply to the variable.
NOTE: int32 nfl=0,
NOTE: specifies the format field length.
NOTE: int32 nfd=0
NOTE: specifies the format precision length.
NOTE: }
NOTE: specifies the variables to use in the action.
NOTE: } (required),
NOTE: specifies the table name, caslib, and other common parameters.
NOTE: list groupbyTable={
NOTE: specifies an input table that contains the groups to use in a group-by analysis.
NOTE: string name=NULL (required),
NOTE: specifies the name of the table to use.
NOTE: string casLib=NULL,
NOTE: specifies the caslib containing the table that you want to use with the action. By default, the active caslib is used. Specify a value only if you need to access a table from a different caslib.
NOTE: string where=NULL
NOTE: specifies an expression for subsetting the input data.
NOTE: },
NOTE: specifies an input table that contains the groups to use in a group-by analysis.
NOTE: array of attributes={
NOTE: string name=NULL (required),
NOTE: specifies the name for the variable.
NOTE: string label=NULL,
NOTE: specifies the descriptive label for the variable.
NOTE: int32 formattedLength=0,
NOTE: specifies the format field length plus the format precision length.
NOTE: string format=NULL,
NOTE: specifies the format to apply to the variable.
NOTE: int32 nfl=0,
NOTE: specifies the format field length.
NOTE: int32 nfd=0
NOTE: specifies the format precision length.
NOTE: } (alias: attribute) (alias: attrs) (alias: attr) (alias: varAttrs),
NOTE: array of inputs={
NOTE: string name=NULL (required),
NOTE: specifies the name for the variable.
NOTE: string label=NULL,
NOTE: specifies the descriptive label for the variable.
NOTE: int32 formattedLength=0,
NOTE: specifies the format field length plus the format precision length.
NOTE: string format=NULL,
NOTE: specifies the format to apply to the variable.
NOTE: int32 nfl=0,
NOTE: specifies the format field length.
NOTE: int32 nfd=0
NOTE: specifies the format precision length.
NOTE: } (alias: input),
NOTE: int64 groupByLimit=9223372036854775807 (value >= 1),
NOTE: specifies the maximum number of levels in a group-by set. When the server determines this number of levels, the server stops and does not return a result. Specify this parameter if you want to avoid creating large result sets in group-by operations.
NOTE: string list orderBy={
NOTE: specifies a list of variables by which to order the result set.
NOTE: },
NOTE: specifies a list of variables by which to order the result set.
NOTE: int64 list orderByAgg={
NOTE: specifies one or more aggregators by which to order the result set.
NOTE: } ('CSS', 'CV', 'MAX', 'MEAN', 'MIN', 'N', 'NMISS', 'PROBT', 'STD', 'STDERR', 'SUM', 'TSTAT', 'USS', 'VAR'),
NOTE: specifies one or more aggregators by which to order the result set.
NOTE: string list orderByDesc={
NOTE: arranges the results in descending order.
NOTE: },
NOTE: arranges the results in descending order.
NOTE: boolean orderByGbyRaw=false (alias: orderByRaw),
NOTE: when set to True, the ordering of the group-by variables is based on the raw values of the variables, not the formatted values.
NOTE: int32 resultLimit=0 (0 <= value <= 2147483647) (alias: limit),
NOTE: specifies the maximum size of the result set returned to the client.
NOTE: list casOut={
NOTE: specifies the settings for an output table.
NOTE: string name=NULL,
NOTE: specifies the name to associate with the table.
NOTE: string caslib=NULL,
NOTE: specifies the name of the caslib to use.
NOTE: string timeStamp=NULL,
NOTE: specifies the timestamp to apply to the table. Specify the value in the form that is appropriate for your session locale.
NOTE: boolean compress=false,
NOTE: when set to True, data compression is applied to the table.
NOTE: boolean replace=false,
NOTE: specifies whether to overwrite an existing table with the same name.
NOTE: int32 replication=1 (value >= 0),
NOTE: specifies the number of copies of the table to make for fault tolerance. Larger values result in slower performance and use more memory, but provide high availability for data in the event of a node failure.
NOTE: string label=NULL,
NOTE: specifies the descriptive label to associate with the table.
NOTE: int64 maxMemSize=0,
NOTE: specifies the maximum amount of physical memory, in bytes, to allocate for the table. After this threshold is reached, the server uses temporary files and operating system facilities for memory management.
NOTE: boolean promote=false,
NOTE: when set to True, the output table is added with a global scope. This enables other sessions to access the table, subject to access controls. The target caslib must also have a global scope.
NOTE: boolean onDemand=true
NOTE: when set to True, table access is less aggressive with virtual memory use.
NOTE: },
NOTE: specifies the settings for an output table.
NOTE: boolean repeat=false,
NOTE: when set to True, the action is repeated.
NOTE: string freq=NULL (alias: frequency),
NOTE: specifies a frequency variable.
NOTE: double ciAlpha=0.05 (0 < value < 1),
NOTE: specifies the level of significance for 100*(1-ciAlpha)% confidence intervals. The default value of 0.05 results in 95% confidence intervals.
NOTE: enum ciType='TWOSIDED' ('LEFT', 'LOWER', 'RIGHT', 'TWOSIDED', 'UPPER'),
NOTE: specifies the type of confidence interval.
NOTE: int64 list subSet={
NOTE: specifies the summary statistics to generate.
NOTE: } ('CSS', 'CV', 'MAX', 'MEAN', 'MIN', 'N', 'NMISS', 'PROBT', 'STD', 'STDERR', 'SUM', 'TSTAT', 'USS', 'VAR') (unique) (alias: summarySubset) (alias: statistics),
NOTE: specifies the summary statistics to generate.
NOTE: string weight=NULL
NOTE: specifies a numeric variable whose values weight the values of the analysis variables.
help FunctionIn addition to the help action, you can also use Python's help function. In this case, you have to specify an action set or action variable. In the code below, we will get the help for the simple action set. In addition to the actions in the action set, you will also get information about the action set's Python class.
In [5]:
help(conn.simple)
Help on Simple in module swat.cas.actions object:
class Simple(CASActionSet)
| Analytics
|
| Actions
| -------
| simple.correlation : Generates a matrix of Pearson product-moment correlation
| coefficients
| simple.crosstab : Performs one-way or two-way tabulations
| simple.distinct : Computes the distinct number of values of the variables in
| the variable list
| simple.freq : Generates a frequency distribution for one or more
| variables
| simple.groupby : Builds BY groups in terms of the variable value
| combinations given the variables in the variable list
| simple.mdsummary : Calculates multidimensional summaries of numeric variables
| simple.numrows : Shows the number of rows in a Cloud Analytic Services table
| simple.paracoord : Generates a parallel coordinates plot of the variables in
| the variable list
| simple.regression : Performs a linear regression up to 3rd-order polynomials
| simple.summary : Generates descriptive statistics of numeric variables such
| as the sample mean, sample variance, sample size, sum of
| squares, and so on
| simple.topk : Returns the top-K and bottom-K distinct values of each
| variable included in the variable list based on a user-
| specified ranking order
|
| Method resolution order:
| Simple
| CASActionSet
| builtins.object
|
| Data and other attributes defined here:
|
| actions = {'correlation': <class 'swat.cas.actions.simple.Correlation'...
|
| ----------------------------------------------------------------------
| Methods inherited from CASActionSet:
|
| __call__(self, *args, **kwargs)
|
| __dir__(self)
|
| __getattr__(self, name)
|
| ----------------------------------------------------------------------
| Class methods inherited from CASActionSet:
|
| from_reflection(asinfo, connection) from builtins.type
| Create a CASActionSet class from reflection information
|
| Parameters
| ----------
| asinfo : dict
| Reflection information from the server
| connection : CAS object
| The connection object to associate with the CASActionSet
|
| Returns
| -------
| CASActionSet class
|
| get_connection() from builtins.type
| Retrieve the registered connection
|
| Since the connection is only held using a weak reference,
| this method will raise a SWATError if the connection object
| no longer exists.
|
| Returns
| -------
| CAS object
| The registered connection object
|
| Raises
| ------
| SWATError
| If the connection object no longer exists
|
| ----------------------------------------------------------------------
| Data descriptors inherited from CASActionSet:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from CASActionSet:
|
| trait_names = None
Alternatively, you can specify a particular action attribute. This will print information about the action parameters and the Python action class.
In [6]:
help(conn.simple.summary)
Help on simple.Summary in module swat.cas.actions object:
class simple.Summary(CASAction)
| Generates descriptive statistics of numeric variables such as the sample mean, sample variance, sample size, sum of squares, and so on
|
| Parameters
| ----------
| table : dict or CASTable
| specifies the table name, caslib, and other common parameters.
|
| table.name : string or CASTable
| specifies the name of the table to use.
|
| table.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| table.where : string, optional
| specifies an expression for subsetting the input data.
|
| table.groupby : list of dicts, optional
| specifies the names of the variables to use for grouping
| results.
|
| table.groupby[*].name : string
| specifies the name for the variable.
|
| table.groupby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.groupby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.groupby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.groupby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.groupby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.groupbyfmts : list, optional
| specifies the format to apply to each group-by variable. To
| avoid specifying a format for a group-by variable, use "" (no
| format).
| Default: []
|
| table.orderby : list of dicts, optional
| specifies the variables to use for ordering observations within
| partitions. This parameter applies to partitioned tables or it
| can be combined with groupBy variables when groupByMode is set to
| REDISTRIBUTE.
|
| table.orderby[*].name : string
| specifies the name for the variable.
|
| table.orderby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.orderby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.orderby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.orderby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.orderby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvars : list of dicts, optional
| specifies the names of the computed variables to create. Specify
| an expression for each variable in the computedVarsProgram
| parameter.
|
| table.computedvars[*].name : string
| specifies the name for the variable.
|
| table.computedvars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.computedvars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.computedvars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.computedvars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.computedvars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvarsprogram : string, optional
| specifies an expression for each computed variable that you
| include in the computedVars parameter.
|
| table.groupbymode : string, optional
| specifies how the server creates groups.
| Default: NOSORT
| Values: NOSORT, REDISTRIBUTE
|
| table.computedondemand : boolean, optional
| when set to True, the computed variables are created when the
| table is loaded instead of when the action begins.
| Default: False
|
| table.singlepass : boolean, optional
| when set to True, the data does not create a transient table in
| the server. Setting this parameter to True can be efficient, but
| the data might not have stable ordering upon repeated runs.
| Default: False
|
| table.importoptions : dict, optional
| specifies the settings for reading a table from a data source.
|
| table.importoptions.filetype : string
| Default: auto
| Values: auto, hdat, csv, delimited, excel, jmp, spss, dta,
| esp, lasr, basesas, mva, xls, fmt
|
| table.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| table.vars : list of dicts, optional
| specifies the variables to use in the action.
|
| table.vars[*].name : string
| specifies the name for the variable.
|
| table.vars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.vars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.vars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.vars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.vars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| nthreads : int32, optional
| specifies the number of threads to use on each machine in the
| server. By default, the server uses one thread for each CPU that is
| licensed to use SAS software.
| Default: 0
| Note: Value range is 0 <= n <= 64
|
| groupbytable : dict or CASTable, optional
| specifies an input table that contains the groups to use in a
| group-by analysis.
|
| groupbytable.name : string or CASTable
| specifies the name of the table to use.
|
| groupbytable.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| groupbytable.where : string, optional
| specifies an expression for subsetting the input data.
|
| attributes : list of dicts, optional
|
| attributes[*].name : string
| specifies the name for the variable.
|
| attributes[*].label : string, optional
| specifies the descriptive label for the variable.
|
| attributes[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| attributes[*].format : string, optional
| specifies the format to apply to the variable.
|
| attributes[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| attributes[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| inputs : list of dicts, optional
|
| inputs[*].name : string
| specifies the name for the variable.
|
| inputs[*].label : string, optional
| specifies the descriptive label for the variable.
|
| inputs[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| inputs[*].format : string, optional
| specifies the format to apply to the variable.
|
| inputs[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| inputs[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| groupbylimit : int64, optional
| specifies the maximum number of levels in a group-by set. When the
| server determines this number of levels, the server stops and does
| not return a result. Specify this parameter if you want to avoid
| creating large result sets in group-by operations.
| Note: Value range is 1 <= n < 9223372036854775807
|
| orderby : list of strings, optional
| specifies a list of variables by which to order the result set.
| Default: []
|
| orderbyagg : list, optional
| specifies one or more aggregators by which to order the result set.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| orderbydesc : list of strings, optional
| arranges the results in descending order.
| Default: []
|
| orderbygbyraw : boolean, optional
| when set to True, the ordering of the group-by variables is based on
| the raw values of the variables, not the formatted values.
| Default: False
|
| resultlimit : int32, optional
| specifies the maximum size of the result set returned to the client.
| Default: 0
| Note: Value range is 0 <= n <= 2147483647
|
| casout : dict or CASTable, optional
| specifies the settings for an output table.
|
| casout.name : string or CASTable, optional
| specifies the name to associate with the table.
|
| casout.caslib : string, optional
| specifies the name of the caslib to use.
|
| casout.timestamp : string, optional
| specifies the timestamp to apply to the table. Specify the value
| in the form that is appropriate for your session locale.
|
| casout.compress : boolean, optional
| when set to True, data compression is applied to the table.
| Default: False
|
| casout.replace : boolean, optional
| specifies whether to overwrite an existing table with the same
| name.
| Default: False
|
| casout.replication : int32, optional
| specifies the number of copies of the table to make for fault
| tolerance. Larger values result in slower performance and use
| more memory, but provide high availability for data in the event
| of a node failure.
| Default: 1
| Note: Value range is 0 <= n < 2147483647
|
| casout.threadblocksize : int64, optional
| specifies the number of bytes to use for blocks that are read by
| threads. Increase this value only if you have a large table and
| CPU utilization by threads shows thread starvation.
| Note: Value range is 0 <= n < 9223372036854775807
|
| casout.label : string, optional
| specifies the descriptive label to associate with the table.
|
| casout.maxmemsize : int64, optional
| specifies the maximum amount of physical memory, in bytes, to
| allocate for the table. After this threshold is reached, the
| server uses temporary files and operating system facilities for
| memory management.
| Default: 0
|
| casout.promote : boolean, optional
| when set to True, the output table is added with a global scope.
| This enables other sessions to access the table, subject to
| access controls. The target caslib must also have a global scope.
| Default: False
|
| casout.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| repeat : boolean, optional
| when set to True, the action is repeated.
| Default: False
|
| freq : string, optional
| specifies a frequency variable.
|
| cialpha : double, optional
| specifies the level of significance for 100*(1-ciAlpha)% confidence
| intervals. The default value of 0.05 results in 95% confidence
| intervals.
| Default: 0.05
| Note: Value range is 0.0 < n < 1.0
|
| citype : string, optional
| specifies the type of confidence interval.
| Default: TWOSIDED
| Values: LEFT, LOWER, RIGHT, TWOSIDED, UPPER
|
| subset : list, optional
| specifies the summary statistics to generate.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| weight : string, optional
| specifies a numeric variable whose values weight the values of the
| analysis variables.
|
| Returns
| -------
| Summary object
|
| Method resolution order:
| simple.Summary
| CASAction
| swat.cas.utils.params.ParamManager
| builtins.object
|
| Methods defined here:
|
| __call__(_self_, table=None, nthreads=None, groupbytable=None, attributes=None, inputs=None, groupbylimit=None, orderby=None, orderbyagg=None, orderbydesc=None, orderbygbyraw=None, resultlimit=None, casout=None, repeat=None, freq=None, cialpha=None, citype=None, subset=None, weight=None, **kwargs)
| Generates descriptive statistics of numeric variables such as the sample mean, sample variance, sample size, sum of squares, and so on
|
| Parameters
| ----------
| table : dict or CASTable
| specifies the table name, caslib, and other common parameters.
|
| table.name : string or CASTable
| specifies the name of the table to use.
|
| table.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| table.where : string, optional
| specifies an expression for subsetting the input data.
|
| table.groupby : list of dicts, optional
| specifies the names of the variables to use for grouping
| results.
|
| table.groupby[*].name : string
| specifies the name for the variable.
|
| table.groupby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.groupby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.groupby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.groupby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.groupby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.groupbyfmts : list, optional
| specifies the format to apply to each group-by variable. To
| avoid specifying a format for a group-by variable, use "" (no
| format).
| Default: []
|
| table.orderby : list of dicts, optional
| specifies the variables to use for ordering observations within
| partitions. This parameter applies to partitioned tables or it
| can be combined with groupBy variables when groupByMode is set to
| REDISTRIBUTE.
|
| table.orderby[*].name : string
| specifies the name for the variable.
|
| table.orderby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.orderby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.orderby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.orderby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.orderby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvars : list of dicts, optional
| specifies the names of the computed variables to create. Specify
| an expression for each variable in the computedVarsProgram
| parameter.
|
| table.computedvars[*].name : string
| specifies the name for the variable.
|
| table.computedvars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.computedvars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.computedvars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.computedvars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.computedvars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvarsprogram : string, optional
| specifies an expression for each computed variable that you
| include in the computedVars parameter.
|
| table.groupbymode : string, optional
| specifies how the server creates groups.
| Default: NOSORT
| Values: NOSORT, REDISTRIBUTE
|
| table.computedondemand : boolean, optional
| when set to True, the computed variables are created when the
| table is loaded instead of when the action begins.
| Default: False
|
| table.singlepass : boolean, optional
| when set to True, the data does not create a transient table in
| the server. Setting this parameter to True can be efficient, but
| the data might not have stable ordering upon repeated runs.
| Default: False
|
| table.importoptions : dict, optional
| specifies the settings for reading a table from a data source.
|
| table.importoptions.filetype : string
| Default: auto
| Values: auto, hdat, csv, delimited, excel, jmp, spss, dta,
| esp, lasr, basesas, mva, xls, fmt
|
| table.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| table.vars : list of dicts, optional
| specifies the variables to use in the action.
|
| table.vars[*].name : string
| specifies the name for the variable.
|
| table.vars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.vars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.vars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.vars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.vars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| nthreads : int32, optional
| specifies the number of threads to use on each machine in the
| server. By default, the server uses one thread for each CPU that is
| licensed to use SAS software.
| Default: 0
| Note: Value range is 0 <= n <= 64
|
| groupbytable : dict or CASTable, optional
| specifies an input table that contains the groups to use in a
| group-by analysis.
|
| groupbytable.name : string or CASTable
| specifies the name of the table to use.
|
| groupbytable.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| groupbytable.where : string, optional
| specifies an expression for subsetting the input data.
|
| attributes : list of dicts, optional
|
| attributes[*].name : string
| specifies the name for the variable.
|
| attributes[*].label : string, optional
| specifies the descriptive label for the variable.
|
| attributes[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| attributes[*].format : string, optional
| specifies the format to apply to the variable.
|
| attributes[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| attributes[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| inputs : list of dicts, optional
|
| inputs[*].name : string
| specifies the name for the variable.
|
| inputs[*].label : string, optional
| specifies the descriptive label for the variable.
|
| inputs[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| inputs[*].format : string, optional
| specifies the format to apply to the variable.
|
| inputs[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| inputs[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| groupbylimit : int64, optional
| specifies the maximum number of levels in a group-by set. When the
| server determines this number of levels, the server stops and does
| not return a result. Specify this parameter if you want to avoid
| creating large result sets in group-by operations.
| Note: Value range is 1 <= n < 9223372036854775807
|
| orderby : list of strings, optional
| specifies a list of variables by which to order the result set.
| Default: []
|
| orderbyagg : list, optional
| specifies one or more aggregators by which to order the result set.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| orderbydesc : list of strings, optional
| arranges the results in descending order.
| Default: []
|
| orderbygbyraw : boolean, optional
| when set to True, the ordering of the group-by variables is based on
| the raw values of the variables, not the formatted values.
| Default: False
|
| resultlimit : int32, optional
| specifies the maximum size of the result set returned to the client.
| Default: 0
| Note: Value range is 0 <= n <= 2147483647
|
| casout : dict or CASTable, optional
| specifies the settings for an output table.
|
| casout.name : string or CASTable, optional
| specifies the name to associate with the table.
|
| casout.caslib : string, optional
| specifies the name of the caslib to use.
|
| casout.timestamp : string, optional
| specifies the timestamp to apply to the table. Specify the value
| in the form that is appropriate for your session locale.
|
| casout.compress : boolean, optional
| when set to True, data compression is applied to the table.
| Default: False
|
| casout.replace : boolean, optional
| specifies whether to overwrite an existing table with the same
| name.
| Default: False
|
| casout.replication : int32, optional
| specifies the number of copies of the table to make for fault
| tolerance. Larger values result in slower performance and use
| more memory, but provide high availability for data in the event
| of a node failure.
| Default: 1
| Note: Value range is 0 <= n < 2147483647
|
| casout.threadblocksize : int64, optional
| specifies the number of bytes to use for blocks that are read by
| threads. Increase this value only if you have a large table and
| CPU utilization by threads shows thread starvation.
| Note: Value range is 0 <= n < 9223372036854775807
|
| casout.label : string, optional
| specifies the descriptive label to associate with the table.
|
| casout.maxmemsize : int64, optional
| specifies the maximum amount of physical memory, in bytes, to
| allocate for the table. After this threshold is reached, the
| server uses temporary files and operating system facilities for
| memory management.
| Default: 0
|
| casout.promote : boolean, optional
| when set to True, the output table is added with a global scope.
| This enables other sessions to access the table, subject to
| access controls. The target caslib must also have a global scope.
| Default: False
|
| casout.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| repeat : boolean, optional
| when set to True, the action is repeated.
| Default: False
|
| freq : string, optional
| specifies a frequency variable.
|
| cialpha : double, optional
| specifies the level of significance for 100*(1-ciAlpha)% confidence
| intervals. The default value of 0.05 results in 95% confidence
| intervals.
| Default: 0.05
| Note: Value range is 0.0 < n < 1.0
|
| citype : string, optional
| specifies the type of confidence interval.
| Default: TWOSIDED
| Values: LEFT, LOWER, RIGHT, TWOSIDED, UPPER
|
| subset : list, optional
| specifies the summary statistics to generate.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| weight : string, optional
| specifies a numeric variable whose values weight the values of the
| analysis variables.
|
| Returns
| -------
| CASResults object
|
| __init__(_self_, table=None, nthreads=None, groupbytable=None, attributes=None, inputs=None, groupbylimit=None, orderby=None, orderbyagg=None, orderbydesc=None, orderbygbyraw=None, resultlimit=None, casout=None, repeat=None, freq=None, cialpha=None, citype=None, subset=None, weight=None, **kwargs)
| Generates descriptive statistics of numeric variables such as the sample mean, sample variance, sample size, sum of squares, and so on
|
| Parameters
| ----------
| table : dict or CASTable
| specifies the table name, caslib, and other common parameters.
|
| table.name : string or CASTable
| specifies the name of the table to use.
|
| table.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| table.where : string, optional
| specifies an expression for subsetting the input data.
|
| table.groupby : list of dicts, optional
| specifies the names of the variables to use for grouping
| results.
|
| table.groupby[*].name : string
| specifies the name for the variable.
|
| table.groupby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.groupby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.groupby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.groupby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.groupby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.groupbyfmts : list, optional
| specifies the format to apply to each group-by variable. To
| avoid specifying a format for a group-by variable, use "" (no
| format).
| Default: []
|
| table.orderby : list of dicts, optional
| specifies the variables to use for ordering observations within
| partitions. This parameter applies to partitioned tables or it
| can be combined with groupBy variables when groupByMode is set to
| REDISTRIBUTE.
|
| table.orderby[*].name : string
| specifies the name for the variable.
|
| table.orderby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.orderby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.orderby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.orderby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.orderby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvars : list of dicts, optional
| specifies the names of the computed variables to create. Specify
| an expression for each variable in the computedVarsProgram
| parameter.
|
| table.computedvars[*].name : string
| specifies the name for the variable.
|
| table.computedvars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.computedvars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.computedvars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.computedvars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.computedvars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvarsprogram : string, optional
| specifies an expression for each computed variable that you
| include in the computedVars parameter.
|
| table.groupbymode : string, optional
| specifies how the server creates groups.
| Default: NOSORT
| Values: NOSORT, REDISTRIBUTE
|
| table.computedondemand : boolean, optional
| when set to True, the computed variables are created when the
| table is loaded instead of when the action begins.
| Default: False
|
| table.singlepass : boolean, optional
| when set to True, the data does not create a transient table in
| the server. Setting this parameter to True can be efficient, but
| the data might not have stable ordering upon repeated runs.
| Default: False
|
| table.importoptions : dict, optional
| specifies the settings for reading a table from a data source.
|
| table.importoptions.filetype : string
| Default: auto
| Values: auto, hdat, csv, delimited, excel, jmp, spss, dta,
| esp, lasr, basesas, mva, xls, fmt
|
| table.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| table.vars : list of dicts, optional
| specifies the variables to use in the action.
|
| table.vars[*].name : string
| specifies the name for the variable.
|
| table.vars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.vars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.vars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.vars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.vars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| nthreads : int32, optional
| specifies the number of threads to use on each machine in the
| server. By default, the server uses one thread for each CPU that is
| licensed to use SAS software.
| Default: 0
| Note: Value range is 0 <= n <= 64
|
| groupbytable : dict or CASTable, optional
| specifies an input table that contains the groups to use in a
| group-by analysis.
|
| groupbytable.name : string or CASTable
| specifies the name of the table to use.
|
| groupbytable.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| groupbytable.where : string, optional
| specifies an expression for subsetting the input data.
|
| attributes : list of dicts, optional
|
| attributes[*].name : string
| specifies the name for the variable.
|
| attributes[*].label : string, optional
| specifies the descriptive label for the variable.
|
| attributes[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| attributes[*].format : string, optional
| specifies the format to apply to the variable.
|
| attributes[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| attributes[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| inputs : list of dicts, optional
|
| inputs[*].name : string
| specifies the name for the variable.
|
| inputs[*].label : string, optional
| specifies the descriptive label for the variable.
|
| inputs[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| inputs[*].format : string, optional
| specifies the format to apply to the variable.
|
| inputs[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| inputs[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| groupbylimit : int64, optional
| specifies the maximum number of levels in a group-by set. When the
| server determines this number of levels, the server stops and does
| not return a result. Specify this parameter if you want to avoid
| creating large result sets in group-by operations.
| Note: Value range is 1 <= n < 9223372036854775807
|
| orderby : list of strings, optional
| specifies a list of variables by which to order the result set.
| Default: []
|
| orderbyagg : list, optional
| specifies one or more aggregators by which to order the result set.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| orderbydesc : list of strings, optional
| arranges the results in descending order.
| Default: []
|
| orderbygbyraw : boolean, optional
| when set to True, the ordering of the group-by variables is based on
| the raw values of the variables, not the formatted values.
| Default: False
|
| resultlimit : int32, optional
| specifies the maximum size of the result set returned to the client.
| Default: 0
| Note: Value range is 0 <= n <= 2147483647
|
| casout : dict or CASTable, optional
| specifies the settings for an output table.
|
| casout.name : string or CASTable, optional
| specifies the name to associate with the table.
|
| casout.caslib : string, optional
| specifies the name of the caslib to use.
|
| casout.timestamp : string, optional
| specifies the timestamp to apply to the table. Specify the value
| in the form that is appropriate for your session locale.
|
| casout.compress : boolean, optional
| when set to True, data compression is applied to the table.
| Default: False
|
| casout.replace : boolean, optional
| specifies whether to overwrite an existing table with the same
| name.
| Default: False
|
| casout.replication : int32, optional
| specifies the number of copies of the table to make for fault
| tolerance. Larger values result in slower performance and use
| more memory, but provide high availability for data in the event
| of a node failure.
| Default: 1
| Note: Value range is 0 <= n < 2147483647
|
| casout.threadblocksize : int64, optional
| specifies the number of bytes to use for blocks that are read by
| threads. Increase this value only if you have a large table and
| CPU utilization by threads shows thread starvation.
| Note: Value range is 0 <= n < 9223372036854775807
|
| casout.label : string, optional
| specifies the descriptive label to associate with the table.
|
| casout.maxmemsize : int64, optional
| specifies the maximum amount of physical memory, in bytes, to
| allocate for the table. After this threshold is reached, the
| server uses temporary files and operating system facilities for
| memory management.
| Default: 0
|
| casout.promote : boolean, optional
| when set to True, the output table is added with a global scope.
| This enables other sessions to access the table, subject to
| access controls. The target caslib must also have a global scope.
| Default: False
|
| casout.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| repeat : boolean, optional
| when set to True, the action is repeated.
| Default: False
|
| freq : string, optional
| specifies a frequency variable.
|
| cialpha : double, optional
| specifies the level of significance for 100*(1-ciAlpha)% confidence
| intervals. The default value of 0.05 results in 95% confidence
| intervals.
| Default: 0.05
| Note: Value range is 0.0 < n < 1.0
|
| citype : string, optional
| specifies the type of confidence interval.
| Default: TWOSIDED
| Values: LEFT, LOWER, RIGHT, TWOSIDED, UPPER
|
| subset : list, optional
| specifies the summary statistics to generate.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| weight : string, optional
| specifies a numeric variable whose values weight the values of the
| analysis variables.
|
| Returns
| -------
| Summary object
|
| get_param(_self_, key)
| Get the value of an action parameter
|
| Parameters
| ----------
| key : string
| The fully-qualified name (e.g., table.name) of the parameter to retrieve.
|
| Valid Parameters
| ----------------
| table : dict or CASTable
| specifies the table name, caslib, and other common parameters.
|
| table.name : string or CASTable
| specifies the name of the table to use.
|
| table.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| table.where : string, optional
| specifies an expression for subsetting the input data.
|
| table.groupby : list of dicts, optional
| specifies the names of the variables to use for grouping
| results.
|
| table.groupby[*].name : string
| specifies the name for the variable.
|
| table.groupby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.groupby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.groupby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.groupby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.groupby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.groupbyfmts : list, optional
| specifies the format to apply to each group-by variable. To
| avoid specifying a format for a group-by variable, use "" (no
| format).
| Default: []
|
| table.orderby : list of dicts, optional
| specifies the variables to use for ordering observations within
| partitions. This parameter applies to partitioned tables or it
| can be combined with groupBy variables when groupByMode is set to
| REDISTRIBUTE.
|
| table.orderby[*].name : string
| specifies the name for the variable.
|
| table.orderby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.orderby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.orderby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.orderby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.orderby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvars : list of dicts, optional
| specifies the names of the computed variables to create. Specify
| an expression for each variable in the computedVarsProgram
| parameter.
|
| table.computedvars[*].name : string
| specifies the name for the variable.
|
| table.computedvars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.computedvars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.computedvars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.computedvars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.computedvars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvarsprogram : string, optional
| specifies an expression for each computed variable that you
| include in the computedVars parameter.
|
| table.groupbymode : string, optional
| specifies how the server creates groups.
| Default: NOSORT
| Values: NOSORT, REDISTRIBUTE
|
| table.computedondemand : boolean, optional
| when set to True, the computed variables are created when the
| table is loaded instead of when the action begins.
| Default: False
|
| table.singlepass : boolean, optional
| when set to True, the data does not create a transient table in
| the server. Setting this parameter to True can be efficient, but
| the data might not have stable ordering upon repeated runs.
| Default: False
|
| table.importoptions : dict, optional
| specifies the settings for reading a table from a data source.
|
| table.importoptions.filetype : string
| Default: auto
| Values: auto, hdat, csv, delimited, excel, jmp, spss, dta,
| esp, lasr, basesas, mva, xls, fmt
|
| table.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| table.vars : list of dicts, optional
| specifies the variables to use in the action.
|
| table.vars[*].name : string
| specifies the name for the variable.
|
| table.vars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.vars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.vars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.vars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.vars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| nthreads : int32, optional
| specifies the number of threads to use on each machine in the
| server. By default, the server uses one thread for each CPU that is
| licensed to use SAS software.
| Default: 0
| Note: Value range is 0 <= n <= 64
|
| groupbytable : dict or CASTable, optional
| specifies an input table that contains the groups to use in a
| group-by analysis.
|
| groupbytable.name : string or CASTable
| specifies the name of the table to use.
|
| groupbytable.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| groupbytable.where : string, optional
| specifies an expression for subsetting the input data.
|
| attributes : list of dicts, optional
|
| attributes[*].name : string
| specifies the name for the variable.
|
| attributes[*].label : string, optional
| specifies the descriptive label for the variable.
|
| attributes[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| attributes[*].format : string, optional
| specifies the format to apply to the variable.
|
| attributes[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| attributes[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| inputs : list of dicts, optional
|
| inputs[*].name : string
| specifies the name for the variable.
|
| inputs[*].label : string, optional
| specifies the descriptive label for the variable.
|
| inputs[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| inputs[*].format : string, optional
| specifies the format to apply to the variable.
|
| inputs[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| inputs[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| groupbylimit : int64, optional
| specifies the maximum number of levels in a group-by set. When the
| server determines this number of levels, the server stops and does
| not return a result. Specify this parameter if you want to avoid
| creating large result sets in group-by operations.
| Note: Value range is 1 <= n < 9223372036854775807
|
| orderby : list of strings, optional
| specifies a list of variables by which to order the result set.
| Default: []
|
| orderbyagg : list, optional
| specifies one or more aggregators by which to order the result set.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| orderbydesc : list of strings, optional
| arranges the results in descending order.
| Default: []
|
| orderbygbyraw : boolean, optional
| when set to True, the ordering of the group-by variables is based on
| the raw values of the variables, not the formatted values.
| Default: False
|
| resultlimit : int32, optional
| specifies the maximum size of the result set returned to the client.
| Default: 0
| Note: Value range is 0 <= n <= 2147483647
|
| casout : dict or CASTable, optional
| specifies the settings for an output table.
|
| casout.name : string or CASTable, optional
| specifies the name to associate with the table.
|
| casout.caslib : string, optional
| specifies the name of the caslib to use.
|
| casout.timestamp : string, optional
| specifies the timestamp to apply to the table. Specify the value
| in the form that is appropriate for your session locale.
|
| casout.compress : boolean, optional
| when set to True, data compression is applied to the table.
| Default: False
|
| casout.replace : boolean, optional
| specifies whether to overwrite an existing table with the same
| name.
| Default: False
|
| casout.replication : int32, optional
| specifies the number of copies of the table to make for fault
| tolerance. Larger values result in slower performance and use
| more memory, but provide high availability for data in the event
| of a node failure.
| Default: 1
| Note: Value range is 0 <= n < 2147483647
|
| casout.threadblocksize : int64, optional
| specifies the number of bytes to use for blocks that are read by
| threads. Increase this value only if you have a large table and
| CPU utilization by threads shows thread starvation.
| Note: Value range is 0 <= n < 9223372036854775807
|
| casout.label : string, optional
| specifies the descriptive label to associate with the table.
|
| casout.maxmemsize : int64, optional
| specifies the maximum amount of physical memory, in bytes, to
| allocate for the table. After this threshold is reached, the
| server uses temporary files and operating system facilities for
| memory management.
| Default: 0
|
| casout.promote : boolean, optional
| when set to True, the output table is added with a global scope.
| This enables other sessions to access the table, subject to
| access controls. The target caslib must also have a global scope.
| Default: False
|
| casout.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| repeat : boolean, optional
| when set to True, the action is repeated.
| Default: False
|
| freq : string, optional
| specifies a frequency variable.
|
| cialpha : double, optional
| specifies the level of significance for 100*(1-ciAlpha)% confidence
| intervals. The default value of 0.05 results in 95% confidence
| intervals.
| Default: 0.05
| Note: Value range is 0.0 < n < 1.0
|
| citype : string, optional
| specifies the type of confidence interval.
| Default: TWOSIDED
| Values: LEFT, LOWER, RIGHT, TWOSIDED, UPPER
|
| subset : list, optional
| specifies the summary statistics to generate.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| weight : string, optional
| specifies a numeric variable whose values weight the values of the
| analysis variables.
|
| Returns
| -------
| any
| The value of the speciifed parameter.
|
| get_params(_self_, *keys)
| Get the value of one or more action parameters
|
| Parameters
| ----------
| *keys : one or more strings
| The fully-qualified names (e.g., table.name) of the parameters to retrieve.
|
| Valid Parameters
| ----------------
| table : dict or CASTable
| specifies the table name, caslib, and other common parameters.
|
| table.name : string or CASTable
| specifies the name of the table to use.
|
| table.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| table.where : string, optional
| specifies an expression for subsetting the input data.
|
| table.groupby : list of dicts, optional
| specifies the names of the variables to use for grouping
| results.
|
| table.groupby[*].name : string
| specifies the name for the variable.
|
| table.groupby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.groupby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.groupby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.groupby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.groupby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.groupbyfmts : list, optional
| specifies the format to apply to each group-by variable. To
| avoid specifying a format for a group-by variable, use "" (no
| format).
| Default: []
|
| table.orderby : list of dicts, optional
| specifies the variables to use for ordering observations within
| partitions. This parameter applies to partitioned tables or it
| can be combined with groupBy variables when groupByMode is set to
| REDISTRIBUTE.
|
| table.orderby[*].name : string
| specifies the name for the variable.
|
| table.orderby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.orderby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.orderby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.orderby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.orderby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvars : list of dicts, optional
| specifies the names of the computed variables to create. Specify
| an expression for each variable in the computedVarsProgram
| parameter.
|
| table.computedvars[*].name : string
| specifies the name for the variable.
|
| table.computedvars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.computedvars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.computedvars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.computedvars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.computedvars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvarsprogram : string, optional
| specifies an expression for each computed variable that you
| include in the computedVars parameter.
|
| table.groupbymode : string, optional
| specifies how the server creates groups.
| Default: NOSORT
| Values: NOSORT, REDISTRIBUTE
|
| table.computedondemand : boolean, optional
| when set to True, the computed variables are created when the
| table is loaded instead of when the action begins.
| Default: False
|
| table.singlepass : boolean, optional
| when set to True, the data does not create a transient table in
| the server. Setting this parameter to True can be efficient, but
| the data might not have stable ordering upon repeated runs.
| Default: False
|
| table.importoptions : dict, optional
| specifies the settings for reading a table from a data source.
|
| table.importoptions.filetype : string
| Default: auto
| Values: auto, hdat, csv, delimited, excel, jmp, spss, dta,
| esp, lasr, basesas, mva, xls, fmt
|
| table.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| table.vars : list of dicts, optional
| specifies the variables to use in the action.
|
| table.vars[*].name : string
| specifies the name for the variable.
|
| table.vars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.vars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.vars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.vars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.vars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| nthreads : int32, optional
| specifies the number of threads to use on each machine in the
| server. By default, the server uses one thread for each CPU that is
| licensed to use SAS software.
| Default: 0
| Note: Value range is 0 <= n <= 64
|
| groupbytable : dict or CASTable, optional
| specifies an input table that contains the groups to use in a
| group-by analysis.
|
| groupbytable.name : string or CASTable
| specifies the name of the table to use.
|
| groupbytable.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| groupbytable.where : string, optional
| specifies an expression for subsetting the input data.
|
| attributes : list of dicts, optional
|
| attributes[*].name : string
| specifies the name for the variable.
|
| attributes[*].label : string, optional
| specifies the descriptive label for the variable.
|
| attributes[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| attributes[*].format : string, optional
| specifies the format to apply to the variable.
|
| attributes[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| attributes[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| inputs : list of dicts, optional
|
| inputs[*].name : string
| specifies the name for the variable.
|
| inputs[*].label : string, optional
| specifies the descriptive label for the variable.
|
| inputs[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| inputs[*].format : string, optional
| specifies the format to apply to the variable.
|
| inputs[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| inputs[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| groupbylimit : int64, optional
| specifies the maximum number of levels in a group-by set. When the
| server determines this number of levels, the server stops and does
| not return a result. Specify this parameter if you want to avoid
| creating large result sets in group-by operations.
| Note: Value range is 1 <= n < 9223372036854775807
|
| orderby : list of strings, optional
| specifies a list of variables by which to order the result set.
| Default: []
|
| orderbyagg : list, optional
| specifies one or more aggregators by which to order the result set.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| orderbydesc : list of strings, optional
| arranges the results in descending order.
| Default: []
|
| orderbygbyraw : boolean, optional
| when set to True, the ordering of the group-by variables is based on
| the raw values of the variables, not the formatted values.
| Default: False
|
| resultlimit : int32, optional
| specifies the maximum size of the result set returned to the client.
| Default: 0
| Note: Value range is 0 <= n <= 2147483647
|
| casout : dict or CASTable, optional
| specifies the settings for an output table.
|
| casout.name : string or CASTable, optional
| specifies the name to associate with the table.
|
| casout.caslib : string, optional
| specifies the name of the caslib to use.
|
| casout.timestamp : string, optional
| specifies the timestamp to apply to the table. Specify the value
| in the form that is appropriate for your session locale.
|
| casout.compress : boolean, optional
| when set to True, data compression is applied to the table.
| Default: False
|
| casout.replace : boolean, optional
| specifies whether to overwrite an existing table with the same
| name.
| Default: False
|
| casout.replication : int32, optional
| specifies the number of copies of the table to make for fault
| tolerance. Larger values result in slower performance and use
| more memory, but provide high availability for data in the event
| of a node failure.
| Default: 1
| Note: Value range is 0 <= n < 2147483647
|
| casout.threadblocksize : int64, optional
| specifies the number of bytes to use for blocks that are read by
| threads. Increase this value only if you have a large table and
| CPU utilization by threads shows thread starvation.
| Note: Value range is 0 <= n < 9223372036854775807
|
| casout.label : string, optional
| specifies the descriptive label to associate with the table.
|
| casout.maxmemsize : int64, optional
| specifies the maximum amount of physical memory, in bytes, to
| allocate for the table. After this threshold is reached, the
| server uses temporary files and operating system facilities for
| memory management.
| Default: 0
|
| casout.promote : boolean, optional
| when set to True, the output table is added with a global scope.
| This enables other sessions to access the table, subject to
| access controls. The target caslib must also have a global scope.
| Default: False
|
| casout.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| repeat : boolean, optional
| when set to True, the action is repeated.
| Default: False
|
| freq : string, optional
| specifies a frequency variable.
|
| cialpha : double, optional
| specifies the level of significance for 100*(1-ciAlpha)% confidence
| intervals. The default value of 0.05 results in 95% confidence
| intervals.
| Default: 0.05
| Note: Value range is 0.0 < n < 1.0
|
| citype : string, optional
| specifies the type of confidence interval.
| Default: TWOSIDED
| Values: LEFT, LOWER, RIGHT, TWOSIDED, UPPER
|
| subset : list, optional
| specifies the summary statistics to generate.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| weight : string, optional
| specifies a numeric variable whose values weight the values of the
| analysis variables.
|
| Returns
| -------
| dict
| A dictionary of key value pairs containing the requested parameters.
|
| set_param(_self_, *args, **kwargs)
| Set one or more action parameters
|
| Parameters
| ----------
| *args : string / any pairs, optional
| Parameters can be specified as fully-qualified names (e.g, table.name)
| and values as subsequent arguments. Any number of name / any pairs
| can be specified.
| **kwargs : any, optional
| Parameters can be specified as any number of keyword arguments.
|
| Examples
| --------
| #
| # String / any pairs
| #
| > summ = s.simple.Sumamry()
| > summ.set_param('table.name', 'iris',
| 'table.singlepass', True,
| 'casout.name', 'iris_summary')
| > print(summ)
| ?.simple.Summary(table={'name': 'iris', 'singlepass': True},
| casout={'name': 'iris_summary'})
|
| #
| # Keywords
| #
| > summ.set_param(casout=dict(name='iris_out'))
| > print(summ)
| ?.simple.Summary(table={'name': 'iris', 'singlepass': True},
| casout={'name': 'iris_out'})
|
| Valid Parameters
| ----------------
| table : dict or CASTable
| specifies the table name, caslib, and other common parameters.
|
| table.name : string or CASTable
| specifies the name of the table to use.
|
| table.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| table.where : string, optional
| specifies an expression for subsetting the input data.
|
| table.groupby : list of dicts, optional
| specifies the names of the variables to use for grouping
| results.
|
| table.groupby[*].name : string
| specifies the name for the variable.
|
| table.groupby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.groupby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.groupby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.groupby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.groupby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.groupbyfmts : list, optional
| specifies the format to apply to each group-by variable. To
| avoid specifying a format for a group-by variable, use "" (no
| format).
| Default: []
|
| table.orderby : list of dicts, optional
| specifies the variables to use for ordering observations within
| partitions. This parameter applies to partitioned tables or it
| can be combined with groupBy variables when groupByMode is set to
| REDISTRIBUTE.
|
| table.orderby[*].name : string
| specifies the name for the variable.
|
| table.orderby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.orderby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.orderby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.orderby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.orderby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvars : list of dicts, optional
| specifies the names of the computed variables to create. Specify
| an expression for each variable in the computedVarsProgram
| parameter.
|
| table.computedvars[*].name : string
| specifies the name for the variable.
|
| table.computedvars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.computedvars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.computedvars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.computedvars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.computedvars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvarsprogram : string, optional
| specifies an expression for each computed variable that you
| include in the computedVars parameter.
|
| table.groupbymode : string, optional
| specifies how the server creates groups.
| Default: NOSORT
| Values: NOSORT, REDISTRIBUTE
|
| table.computedondemand : boolean, optional
| when set to True, the computed variables are created when the
| table is loaded instead of when the action begins.
| Default: False
|
| table.singlepass : boolean, optional
| when set to True, the data does not create a transient table in
| the server. Setting this parameter to True can be efficient, but
| the data might not have stable ordering upon repeated runs.
| Default: False
|
| table.importoptions : dict, optional
| specifies the settings for reading a table from a data source.
|
| table.importoptions.filetype : string
| Default: auto
| Values: auto, hdat, csv, delimited, excel, jmp, spss, dta,
| esp, lasr, basesas, mva, xls, fmt
|
| table.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| table.vars : list of dicts, optional
| specifies the variables to use in the action.
|
| table.vars[*].name : string
| specifies the name for the variable.
|
| table.vars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.vars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.vars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.vars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.vars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| nthreads : int32, optional
| specifies the number of threads to use on each machine in the
| server. By default, the server uses one thread for each CPU that is
| licensed to use SAS software.
| Default: 0
| Note: Value range is 0 <= n <= 64
|
| groupbytable : dict or CASTable, optional
| specifies an input table that contains the groups to use in a
| group-by analysis.
|
| groupbytable.name : string or CASTable
| specifies the name of the table to use.
|
| groupbytable.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| groupbytable.where : string, optional
| specifies an expression for subsetting the input data.
|
| attributes : list of dicts, optional
|
| attributes[*].name : string
| specifies the name for the variable.
|
| attributes[*].label : string, optional
| specifies the descriptive label for the variable.
|
| attributes[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| attributes[*].format : string, optional
| specifies the format to apply to the variable.
|
| attributes[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| attributes[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| inputs : list of dicts, optional
|
| inputs[*].name : string
| specifies the name for the variable.
|
| inputs[*].label : string, optional
| specifies the descriptive label for the variable.
|
| inputs[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| inputs[*].format : string, optional
| specifies the format to apply to the variable.
|
| inputs[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| inputs[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| groupbylimit : int64, optional
| specifies the maximum number of levels in a group-by set. When the
| server determines this number of levels, the server stops and does
| not return a result. Specify this parameter if you want to avoid
| creating large result sets in group-by operations.
| Note: Value range is 1 <= n < 9223372036854775807
|
| orderby : list of strings, optional
| specifies a list of variables by which to order the result set.
| Default: []
|
| orderbyagg : list, optional
| specifies one or more aggregators by which to order the result set.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| orderbydesc : list of strings, optional
| arranges the results in descending order.
| Default: []
|
| orderbygbyraw : boolean, optional
| when set to True, the ordering of the group-by variables is based on
| the raw values of the variables, not the formatted values.
| Default: False
|
| resultlimit : int32, optional
| specifies the maximum size of the result set returned to the client.
| Default: 0
| Note: Value range is 0 <= n <= 2147483647
|
| casout : dict or CASTable, optional
| specifies the settings for an output table.
|
| casout.name : string or CASTable, optional
| specifies the name to associate with the table.
|
| casout.caslib : string, optional
| specifies the name of the caslib to use.
|
| casout.timestamp : string, optional
| specifies the timestamp to apply to the table. Specify the value
| in the form that is appropriate for your session locale.
|
| casout.compress : boolean, optional
| when set to True, data compression is applied to the table.
| Default: False
|
| casout.replace : boolean, optional
| specifies whether to overwrite an existing table with the same
| name.
| Default: False
|
| casout.replication : int32, optional
| specifies the number of copies of the table to make for fault
| tolerance. Larger values result in slower performance and use
| more memory, but provide high availability for data in the event
| of a node failure.
| Default: 1
| Note: Value range is 0 <= n < 2147483647
|
| casout.threadblocksize : int64, optional
| specifies the number of bytes to use for blocks that are read by
| threads. Increase this value only if you have a large table and
| CPU utilization by threads shows thread starvation.
| Note: Value range is 0 <= n < 9223372036854775807
|
| casout.label : string, optional
| specifies the descriptive label to associate with the table.
|
| casout.maxmemsize : int64, optional
| specifies the maximum amount of physical memory, in bytes, to
| allocate for the table. After this threshold is reached, the
| server uses temporary files and operating system facilities for
| memory management.
| Default: 0
|
| casout.promote : boolean, optional
| when set to True, the output table is added with a global scope.
| This enables other sessions to access the table, subject to
| access controls. The target caslib must also have a global scope.
| Default: False
|
| casout.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| repeat : boolean, optional
| when set to True, the action is repeated.
| Default: False
|
| freq : string, optional
| specifies a frequency variable.
|
| cialpha : double, optional
| specifies the level of significance for 100*(1-ciAlpha)% confidence
| intervals. The default value of 0.05 results in 95% confidence
| intervals.
| Default: 0.05
| Note: Value range is 0.0 < n < 1.0
|
| citype : string, optional
| specifies the type of confidence interval.
| Default: TWOSIDED
| Values: LEFT, LOWER, RIGHT, TWOSIDED, UPPER
|
| subset : list, optional
| specifies the summary statistics to generate.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| weight : string, optional
| specifies a numeric variable whose values weight the values of the
| analysis variables.
|
| Returns
| -------
| None
|
| set_params(_self_, *args, **kwargs)
| Set one or more action parameters
|
| Parameters
| ----------
| *args : string / any pairs, optional
| Parameters can be specified as fully-qualified names (e.g, table.name)
| and values as subsequent arguments. Any number of name / any pairs
| can be specified.
| **kwargs : any, optional
| Parameters can be specified as any number of keyword arguments.
|
| Examples
| --------
| #
| # String / any pairs
| #
| > summ = s.simple.Sumamry()
| > summ.set_param('table.name', 'iris',
| 'table.singlepass', True,
| 'casout.name', 'iris_summary')
| > print(summ)
| ?.simple.Summary(table={'name': 'iris', 'singlepass': True},
| casout={'name': 'iris_summary'})
|
| #
| # Keywords
| #
| > summ.set_param(casout=dict(name='iris_out'))
| > print(summ)
| ?.simple.Summary(table={'name': 'iris', 'singlepass': True},
| casout={'name': 'iris_out'})
|
| Valid Parameters
| ----------------
| table : dict or CASTable
| specifies the table name, caslib, and other common parameters.
|
| table.name : string or CASTable
| specifies the name of the table to use.
|
| table.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| table.where : string, optional
| specifies an expression for subsetting the input data.
|
| table.groupby : list of dicts, optional
| specifies the names of the variables to use for grouping
| results.
|
| table.groupby[*].name : string
| specifies the name for the variable.
|
| table.groupby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.groupby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.groupby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.groupby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.groupby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.groupbyfmts : list, optional
| specifies the format to apply to each group-by variable. To
| avoid specifying a format for a group-by variable, use "" (no
| format).
| Default: []
|
| table.orderby : list of dicts, optional
| specifies the variables to use for ordering observations within
| partitions. This parameter applies to partitioned tables or it
| can be combined with groupBy variables when groupByMode is set to
| REDISTRIBUTE.
|
| table.orderby[*].name : string
| specifies the name for the variable.
|
| table.orderby[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.orderby[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.orderby[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.orderby[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.orderby[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvars : list of dicts, optional
| specifies the names of the computed variables to create. Specify
| an expression for each variable in the computedVarsProgram
| parameter.
|
| table.computedvars[*].name : string
| specifies the name for the variable.
|
| table.computedvars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.computedvars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.computedvars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.computedvars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.computedvars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| table.computedvarsprogram : string, optional
| specifies an expression for each computed variable that you
| include in the computedVars parameter.
|
| table.groupbymode : string, optional
| specifies how the server creates groups.
| Default: NOSORT
| Values: NOSORT, REDISTRIBUTE
|
| table.computedondemand : boolean, optional
| when set to True, the computed variables are created when the
| table is loaded instead of when the action begins.
| Default: False
|
| table.singlepass : boolean, optional
| when set to True, the data does not create a transient table in
| the server. Setting this parameter to True can be efficient, but
| the data might not have stable ordering upon repeated runs.
| Default: False
|
| table.importoptions : dict, optional
| specifies the settings for reading a table from a data source.
|
| table.importoptions.filetype : string
| Default: auto
| Values: auto, hdat, csv, delimited, excel, jmp, spss, dta,
| esp, lasr, basesas, mva, xls, fmt
|
| table.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| table.vars : list of dicts, optional
| specifies the variables to use in the action.
|
| table.vars[*].name : string
| specifies the name for the variable.
|
| table.vars[*].label : string, optional
| specifies the descriptive label for the variable.
|
| table.vars[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| table.vars[*].format : string, optional
| specifies the format to apply to the variable.
|
| table.vars[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| table.vars[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| nthreads : int32, optional
| specifies the number of threads to use on each machine in the
| server. By default, the server uses one thread for each CPU that is
| licensed to use SAS software.
| Default: 0
| Note: Value range is 0 <= n <= 64
|
| groupbytable : dict or CASTable, optional
| specifies an input table that contains the groups to use in a
| group-by analysis.
|
| groupbytable.name : string or CASTable
| specifies the name of the table to use.
|
| groupbytable.caslib : string, optional
| specifies the caslib containing the table that you want to use
| with the action. By default, the active caslib is used. Specify a
| value only if you need to access a table from a different caslib.
|
| groupbytable.where : string, optional
| specifies an expression for subsetting the input data.
|
| attributes : list of dicts, optional
|
| attributes[*].name : string
| specifies the name for the variable.
|
| attributes[*].label : string, optional
| specifies the descriptive label for the variable.
|
| attributes[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| attributes[*].format : string, optional
| specifies the format to apply to the variable.
|
| attributes[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| attributes[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| inputs : list of dicts, optional
|
| inputs[*].name : string
| specifies the name for the variable.
|
| inputs[*].label : string, optional
| specifies the descriptive label for the variable.
|
| inputs[*].formattedlength : int32, optional
| specifies the format field length plus the format precision
| length.
| Default: 0
|
| inputs[*].format : string, optional
| specifies the format to apply to the variable.
|
| inputs[*].nfl : int32, optional
| specifies the format field length.
| Default: 0
|
| inputs[*].nfd : int32, optional
| specifies the format precision length.
| Default: 0
|
| groupbylimit : int64, optional
| specifies the maximum number of levels in a group-by set. When the
| server determines this number of levels, the server stops and does
| not return a result. Specify this parameter if you want to avoid
| creating large result sets in group-by operations.
| Note: Value range is 1 <= n < 9223372036854775807
|
| orderby : list of strings, optional
| specifies a list of variables by which to order the result set.
| Default: []
|
| orderbyagg : list, optional
| specifies one or more aggregators by which to order the result set.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| orderbydesc : list of strings, optional
| arranges the results in descending order.
| Default: []
|
| orderbygbyraw : boolean, optional
| when set to True, the ordering of the group-by variables is based on
| the raw values of the variables, not the formatted values.
| Default: False
|
| resultlimit : int32, optional
| specifies the maximum size of the result set returned to the client.
| Default: 0
| Note: Value range is 0 <= n <= 2147483647
|
| casout : dict or CASTable, optional
| specifies the settings for an output table.
|
| casout.name : string or CASTable, optional
| specifies the name to associate with the table.
|
| casout.caslib : string, optional
| specifies the name of the caslib to use.
|
| casout.timestamp : string, optional
| specifies the timestamp to apply to the table. Specify the value
| in the form that is appropriate for your session locale.
|
| casout.compress : boolean, optional
| when set to True, data compression is applied to the table.
| Default: False
|
| casout.replace : boolean, optional
| specifies whether to overwrite an existing table with the same
| name.
| Default: False
|
| casout.replication : int32, optional
| specifies the number of copies of the table to make for fault
| tolerance. Larger values result in slower performance and use
| more memory, but provide high availability for data in the event
| of a node failure.
| Default: 1
| Note: Value range is 0 <= n < 2147483647
|
| casout.threadblocksize : int64, optional
| specifies the number of bytes to use for blocks that are read by
| threads. Increase this value only if you have a large table and
| CPU utilization by threads shows thread starvation.
| Note: Value range is 0 <= n < 9223372036854775807
|
| casout.label : string, optional
| specifies the descriptive label to associate with the table.
|
| casout.maxmemsize : int64, optional
| specifies the maximum amount of physical memory, in bytes, to
| allocate for the table. After this threshold is reached, the
| server uses temporary files and operating system facilities for
| memory management.
| Default: 0
|
| casout.promote : boolean, optional
| when set to True, the output table is added with a global scope.
| This enables other sessions to access the table, subject to
| access controls. The target caslib must also have a global scope.
| Default: False
|
| casout.ondemand : boolean, optional
| when set to True, table access is less aggressive with virtual
| memory use.
| Default: True
|
| repeat : boolean, optional
| when set to True, the action is repeated.
| Default: False
|
| freq : string, optional
| specifies a frequency variable.
|
| cialpha : double, optional
| specifies the level of significance for 100*(1-ciAlpha)% confidence
| intervals. The default value of 0.05 results in 95% confidence
| intervals.
| Default: 0.05
| Note: Value range is 0.0 < n < 1.0
|
| citype : string, optional
| specifies the type of confidence interval.
| Default: TWOSIDED
| Values: LEFT, LOWER, RIGHT, TWOSIDED, UPPER
|
| subset : list, optional
| specifies the summary statistics to generate.
| Default: []
| Values: CSS, CV, MAX, MEAN, MIN, N, NMISS, PROBT, STD, STDERR, SUM,
| TSTAT, USS, VAR
|
| weight : string, optional
| specifies a numeric variable whose values weight the values of the
| analysis variables.
|
| Returns
| -------
| None
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| all_params = set(['attributes', 'attributes[*].format', 'attributes[*]...
|
| param_names = ['table', 'nthreads', 'groupbytable', 'attributes', 'inp...
|
| ----------------------------------------------------------------------
| Methods inherited from CASAction:
|
| __iter__(self)
| Call the action and iterate over the results
|
| invoke(self, **kwargs)
| Invoke the action
|
| Parameters
| ----------
| **kwargs : any, optional
| Arbitrary key/value pairs to add to the arguments sent to the
| action. These key/value pairs are not added to the collection
| of parameters set on the action object. They are only used in
| this call.
|
| Returns
| -------
| self
| Returns the CASAction object itself
|
| retrieve = __call__(self, **kwargs)
| Call the action
|
| Parameters
| ----------
| **kwargs : any, optional
| Arbitrary key/value pairs to add to the arguments sent to the
| action. These key/value pairs are not added to the collection
| of parameters set on the action object. They are only used in
| this call.
|
| Returns
| -------
| CASResults object
| Collection of results from the action call
|
| ----------------------------------------------------------------------
| Class methods inherited from CASAction:
|
| from_reflection(asname, actinfo, connection) from builtins.type
| Construct a CASAction class from reflection information
|
| Parameters
| ----------
| asname : string
| The action set name
| actinfo : dict
| The reflection information for the action
| connection : CAS object
| The connection to associate with the CASAction
| defaults : dict
| Default parameters for the action
|
| Returns
| -------
| CASAction class
|
| get_connection() from builtins.type
| Return the registered connection
|
| The connection is only held by a weak reference. If the
| connection no longer exists, a SWATError is raised.
|
| Raises
| ------
| SWATError
| If the registered connection no longer exists
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from CASAction:
|
| trait_names = None
|
| ----------------------------------------------------------------------
| Methods inherited from swat.cas.utils.params.ParamManager:
|
| __delattr__(self, name)
| Delete an attribute
|
| __enter__(self)
|
| __exit__(self, type, value, traceback)
|
| __getattr__(self, name)
| Get named attribute
|
| __repr__(self)
|
| __setattr__(self, name, value)
| Set an attribute
|
| __str__(self)
|
| del_param = del_params(self, *keys)
| Delete parameters
|
| Parameters
| ----------
| *keys : strings
| Names of parameters to delete
|
| Returns
| -------
| None
|
| del_params(self, *keys)
| Delete parameters
|
| Parameters
| ----------
| *keys : strings
| Names of parameters to delete
|
| Returns
| -------
| None
|
| has_param = has_params(self, *keys)
| Return a boolean indicating whether or not the parameters exist
|
| Parameters
| ----------
| *keys : one or more strings
| Names of parameters
|
| Returns
| -------
| True or False
|
| has_params(self, *keys)
| Return a boolean indicating whether or not the parameters exist
|
| Parameters
| ----------
| *keys : one or more strings
| Names of parameters
|
| Returns
| -------
| True or False
|
| to_dict(self)
| Return the parameters as a dictionary
|
| to_json(self, *args, **kwargs)
| Convert parameters to JSON
|
| Parameters
| ----------
| *args : any, optional
| Additional arguments to json.dumps
| **kwargs : any, optional
| Additional arguments to json.dumps
|
| Returns
| -------
| string
|
| to_params = to_dict(self)
| Return the parameters as a dictionary
|
| ----------------------------------------------------------------------
| Data descriptors inherited from swat.cas.utils.params.ParamManager:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
In [7]:
conn.simple?
The ? operator also works with action names.
In [8]:
conn.simple.summary?
Which one of the above described methods of getting help on CAS actions that you decide to use really depends on what type of information you are looking for and what environment you are in. If you are commonly working in IPython, the ? operator method is likely to be your best bet. If you simply want to see what actions are available in an action set, you may just call the help action directly. And if you are looking for information about the action as well as the Python action class methods, then Python's help function is what you are looking for.
In [9]:
conn.close()
In [ ]:
Content source: sassoftware/sas-viya-programming
Similar notebooks: